package backpage.service.Impl;

import backpage.entity.Employee;
import backpage.mapper.EmployeeMapper;
import backpage.service.EmployeeService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class EmployeeServiceImpl implements EmployeeService {

    @Autowired
    private EmployeeMapper employeeMapper;

    /**
     * 生成一个唯一的用户名。
     * 该方法通过随机生成指定长度的用户名，并检查数据库中是否已存在该用户名。
     * 如果生成的用户名在数据库中不存在，则返回该用户名；否则继续尝试生成新的用户名。
     * @author 吴文钦
     * @return 返回生成的唯一用户账号，如果多次尝试后仍未生成唯一用户账号，则返回null
     */
    @Override
    public String generateUniqueUsername() {
        // 定义用户名的长度
        final int USERNAME_LENGTH = 12;
        // 每次尝试生成的用户名数量
        final int CANDIDATES_PER_ATTEMPT = 10;

        // 定义可用字符集
        String characters = "0123456789";
        // 尝试生成多个用户名
        for (int i = 0; i < CANDIDATES_PER_ATTEMPT; i++) {
            // 使用StringBuilder构建用户名
            StringBuilder username = new StringBuilder(USERNAME_LENGTH);
            // 生成指定长度的用户名
            for (int j = 0; j < USERNAME_LENGTH; j++) {
                // 随机选择一个字符
                int index = (int) (Math.random() * characters.length());
                username.append(characters.charAt(index));
            }
            // 将生成的用户名转换为字符串
            String candidate = username.toString();
            // 使用BaseMapper的selectCount方法检查用户名是否重复
            Boolean count = employeeMapper.selectOne(
                    new LambdaQueryWrapper<Employee>()
                            .select(Employee::getEmployeeId) // 只查询主键字段s，提高效率
                            .eq(Employee::getAccount, candidate)
            ) != null;
            // 如果生成的用户名在数据库中不存在，返回该用户名
            if (!count) {
                return candidate;
            }
        }
        // 如果多次尝试后仍未生成唯一用户名，返回null
        return null;
    }
    /**
     * 查询全部人员信息
     * @author 吴文钦
     * @return 返回所有人员的信息
     */
    @Override
    public List<Employee> queryAllEmployeeInfo() {
        return employeeMapper.selectList(null);
    }

    /**
     * 根据role查询员工信息
     * @param role
     * @return 返回员工列表信息
     */
    public List<Employee> queryEmpInfoByRole(Integer role) {
        return employeeMapper.selectList(
                new LambdaQueryWrapper<Employee>()
                        .eq(Employee::getRole, role)
        );
    }
    /**
     * 根据员工号查询员工信息
     * @param employeeNo
     * author 吴文钦
     * @return 返回员工信息
     */
    @Override
    public Employee queryEmpInfoByEmployeeNo(String employeeNo) {
        return employeeMapper.selectOne(
                new LambdaQueryWrapper<Employee>()
                        .eq(Employee::getEmployeeNo, employeeNo)
        );
    }
    /**
     * 根据员工姓名查询员工信息
     * @param employeeName
     *  author 吴文钦
     * @return 返回员工信息
     */
    public List<Employee> queryEmpInfoByEmployeeName(String employeeName) {
        return employeeMapper.selectList(
                new LambdaQueryWrapper<Employee>()
                        .eq(Employee::getEmployeeName, employeeName)
        );
    }
    /**
     * 根据id查询员工信息
     * @param employeeId
     * author 吴文钦
     * @return 返回员工信息
     */
    @Override
    public Employee queryEmpInfoById(Integer employeeId) {
        return employeeMapper.selectById(employeeId);
    }


    /**
     * 登录，登录后返回该员工信息
     * @param account
     * @param password
     * author 吴文钦
     * @return 返回员工信息
     */
    @Override
    public Employee login(String account, String password) {
        QueryWrapper<Employee> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("account" , account);
        List<Employee> employeeList = employeeMapper.selectList(queryWrapper);
        if(employeeList.size() == 0) {
            System.out.println("没有该用户信息！");
            return null;
        }
        if(employeeList.get(0).getPassword().equals(password)){
            return employeeList.get(0);
        }else {
            System.out.println("密码不正确！");
            return null;
        }
    }




    /**
     * 修改员工信息
     * @param employee
     * @return 修改是否成功
     */
    @Override
    public boolean updateEmpInfo(Employee employee) {
        try {
            // 1. 更新员工基本信息
            int updateCount = employeeMapper.updateById(employee);
            return updateCount == 1;
        } catch (Exception e) {
            throw new RuntimeException("更新员工信息失败", e);
        }
    }

    @Override
    public List<Employee> getoperator(Integer departmentId, Integer role) {
        return employeeMapper.selectList(
                new LambdaQueryWrapper<Employee>()
                        // 添加部门ID查询条件
                        .eq(departmentId != null, Employee::getDepartmentId, departmentId)
                        // 添加角色查询条件
                        .eq(role != null, Employee::getRole, role)
        );

    }
}
